Method for debugging reconfigurable architectures

ABSTRACT

A method is described for debugging reconfigurable hardware. In one example embodiment, debugging information is written for each configuration cycle into a memory which is then evaluated by a debugger.

[0001] The present invention relates to methods for debugging programs on configurable architectures. A reconfigurable architecture is understood to be chips (VPU) with configurable function and/or networking, particularly integrated chips with a multiplicity of arithmetic and/or logic and/or analog and/or storing and/or networking modules arranged one-dimensionally or multidimensionally (called PAEs in the text which follows) and/or communicative/peripheral modules (IO) which are connected to one another either directly or by one or more bus system(s). PAEs are arranged in any design, mixture and hierarchy. This arrangement will be called PAE array or PA in the further text.

[0002] The generic type of these chips includes systolic arrays, neuron networks, multiprocessor systems, processors having a number of arithmetic logic units and/or logic cells, networking and network chips such as e.g. crossbar switches and also known chips of the generic FPGA, DPGA, XPUTER etc. type. Particular reference is made in this context to the following patents by the same applicant: P 44 16 881.0-53, DE 197 81 412.3, DE 197 81 483.2, DE 196 54 846.2-53, DE 196 54 593.5-53, DE 197 04 044.6-53, DE 198 80 129.7, DE 198 61 088.2-53, DE 199 80 312.9, PCT/DE 00/01869, DE 100 36 627.9-33, DE 100 28 397.7, DE 101 10 530.4, DE 101 11 014.6, PCT/EP 00/10516, EP 01 102 674.7. These are herewith incorporated to their full extent for purposes of disclosure.

[0003] It should also be noted that the methods can also be applied to groups of a number of chips.

[0004] A number of methods and hardware implementations are presented which enable VPU systems to be efficiently debugged.

[0005] 1. Method According to the Invention

[0006] Debugging takes place either by using a microcontroller appropriately connected to a VPU or by a loading logic according to the patents PACT01, 02, 04, 05, 09, 10, 11, 13, 17, which are incorporated to their full extent by reference.

[0007] The following fundamental methods will be used in this context:

[0008] 1.1 Detection of a Debugging Condition

[0009] 1.1.1 Condition

[0010] The programmer specifies, for example within the debugging tool, one or more conditions which start the debugging. The occurrence of the conditions is determined at run time in the VPU. This takes place due to the occurrence of particular data values at particular variables and/or particular trigger values at particular PAEs.

[0011] 1.1.2 Precondition

[0012] In the optimum case, a particular condition according to the abovementioned definition can be established by the programmer a number of clock cycles before the occurrence of the debugging condition. This eliminates right from the start particular latency problems which will be discussed in the text which follows.

[0013] In the text which follows, two fundamental types of debugging for VPUs will be discussed, the method to be preferably used in each case depending on the choice of compiler:

[0014] For compilers which generate code on the basis of instanced modules of a hardware description language (or similar language), method A is particularly suitable and will be described in the text which follows.

[0015] For compilers similar to PACT11 which generate complex instructions in accordance with a method similar to VLIW, method B is particularly suitable and will be described in the text which follows.

[0016] 2. Method A

[0017] 2.1 Basic Principle

[0018] After the occurrence of a (pre)condition, the VPU is stopped. After that, the relevant debugging information is transferred from the PAEs to the debugging program. The relevant debugging information has previously been established by the programmer in the debugging program. After all relevant debugging information has been read out, the next clock cycle is executed and the relevant debugging information is again read out. This is repeated until the programmer terminates the debugging process.

[0019] 2.2 Support by the Hardware

[0020] 2.2.1 Reading out the Registers

[0021] An essential factor for the operation of the debugger is the possibility for the CT or another processor connected externally (called debugging processor (DB) in the text which follows) to read back in the internal data registers and/or status registers and/or state registers and if possible, depending on implementation, other relevant registers and/or signals from the PAEs and/or the network (collectively known as debugging information in the text which follows). Such a possibility can be implemented, for example, with the connection between the loading logic and the data bus of a PAE created in PACT08/PCT (PACT08/PCT 0403, FIG. 4).

[0022] It should be expressly noted that serial methods can also be used for reading out the registers. For example, JTAG can be selected and DB can also be connected, if necessary, as external separate device via this method.

[0023] 2.2.2 Stopping or Slowing Down the Clock

[0024] Due to the occurrence of condition and/or precondition, the clock can either be stopped or slowed down in order to provide sufficient readout time. This beginning of debugging is triggered either directly by a PAE which calculated the (pre)condition(s) or by a loading logic due to any actions, for example due to the information that a (pre)condition occurred at a PAE and/or due to an action within the debugging processor and/or by any program and/or any external/peripheral source. To provide information, trigger mechanisms according to PACT01, PACT02, PACT08, PACT10, PACT12, PACT17 are available.

[0025] If the clock is slowed down, all relevant debugging information must be read out of the PAEs by the debugging processor within the slowed-down cycle of the processing clock.

[0026] If the clock is stopped, a single-step mode is produced, i.e. the debugging processor stops the processing clock until it has read out all debugging information. After that, it restarts the processing clock for one cycle and stops it again until all relevant debugging information has been read out.

[0027] The readout clock and the clock of the debugging processor are independent of the processing clock of the PAEs so that the data processing is separate from the debugging and particularly the reading out of the debugging information.

[0028] With respect to the hardware, the stopping or slowing down of the clock is achieved by methods of the prior art such as, for example, gated clocks and/or PLLs and/or dividers or other methods.

[0029] 2.2.3 Register Pipeline for Compensating for Latency

[0030] At higher operating frequencies, latency may occur between the detection of the beginning of debugging and the stopping or slowing down of the clock. This latency can be precisely predetermined since the position of the delaying registers in the VPU is defined by hardware and/or the algorithm to be debugged and can, therefore, be calculated precisely by the debugger.

[0031] However, the latency shifts the information provided to the debugging processor, in such a manner that it is no longer possible to read out the correct debugging information.

[0032] By inserting a multistage register pipeline which transmits the debugging information in each clock cycle further by one register, the debugging processor can refer back to the same number of clock cycles of debugging information as the register pipeline is long.

[0033] Due to the precise calculability of the latency, the debugging program can now read out the relevant debugging information of the correct time from the register pipeline.

[0034] 2.3 Visible Debugging Information

[0035] In this method, debugging essentially takes place after the occurrence of the (pre)condition since it is only after that that the clock is slowed down or stopped and the debugging information is read out. Debugging information from before the occurrence of the (pre)condition is not visible initially.

[0036] However, it is possible, although with the loss of operating performance, to operate a VPU with slowed-down clock or single-step mode right from the start of an application. The relevant debugging information is read out by the debugging processor from the start.

[0037] 3. Method B

[0038] 3.1 Basic Principle

[0039] Relevant debugging information from the memory units which, according to PACT01, 04, 13, 11, 18, contain the application data and states of a particular operating step, are transmitted to the debugging program. In the machine model of PACT01, 04, 11, 13, 18, these memory units operate as registers for storing data which have been calculated in the PA or parts of the PA within a configuration cycle. A memory unit consists of an arbitrary arrangement and hierarchy of independent and dependent memories. It is possible to execute simultaneously a number of different algorithms on the PA which then use different memories.

[0040] It is essential for the application of this method that data and/or algorithmically relevant states are stored in the memory units associated with the PAEs. A memory unit is in each case dimensioned at least in such a manner that all relevant data and/or states of a cycle can be stored, the length of a cycle being typically determined by the size of the memory unit.

[0041] Different data and/or states are stored in the memory units in such a manner that they can be unambiguously correlated with the algorithm. As a result, the debugger can unambiguously identify the relevant data and/or states (debugging information).

[0042] The relevant debugging information has been previously specified by the programmer within the debugging program. This debugging information is read out of the memory units. Different methods are available for this and some possibilities will be described in greater detail in the text which follows. After all relevant debugging information has been read out, the next configuration cycle is executed and the relevant debugging information is again read out. This is repeated until the programmer/debugger terminates the debugging process.

[0043] In other words, the relevant data and/or status information are transmitted to the debugger not clock cycle by clock cycle but configuration by configuration. This occurs from the memory units which are comparable to the registers of a CPU.

[0044] 3.2 Support by the Hardware

[0045] The essential factor for the operation of the debugger is the possibility for the CT or any other processor connected externally (called debugging processor (DB) in the text which follows) to read the, for example, also internal, memory unit of the VPU. Such a possibility is given, for example, by the CT being connected to the memories for preloading and reading the data and/or by the methods for writing the internal memories to external memories, described in PACT13. Memory (units) can be accessed by the debugging processor by various methods of the prior art (e.g. shared memory, bank switching).

[0046] According to method A, the clock for reading out the memories is either correspondingly slowed down, if necessary, or stopped and generated in single-step mode. In this arrangement, special intervention in the clock can be omitted depending on the implementation of the memories, e.g. in the case of the bank switching method. According to method B, stopping or slowing down the clock and reading out and/or copying and/or switching of the memory unit is typically done only when a data processing cycle or configuration cycle has ended.

[0047] 3.3 Access to Debugging Information

[0048] In PACT01, PACT04, PACT11, PACT13, data processing methods are described in which a set of operations are cyclically mapped to a reconfigurable data processing chip. In each cycle, a plurality of data are calculated which originate from a peripheral source and/or an internal/external memory and are written to a peripheral source and/or an internal/external memory. In this arrangement, different and/or, above all, a number of independent memories can be used simultaneously in each case.

[0049] In other words, the memory units or a part of the memory units can be used as register set in this data processing method.

[0050] According to PACT11 and PACT13, all data and states which are relevant for the further data processing are stored in the memory units or read out of these. States which are irrelevant for the further data processing are not stored.

[0051] The distinction between relevant and irrelevant states will be demonstrated in the following example and special reference is made to the statements in PACT11: The state information of a comparison is essential, for example, for the further processing of the data since it determines the functions to be executed.

[0052] A sequential divider is produced, for example, by mapping a division instruction onto a hardware which only supports sequential division. This produces a state which identifies the computing step within the division. This state is irrelevant since only the result (i.e. the division performed) is required for the algorithm. In this case, therefore, only the result and the time information (i.e. the availability) are needed.

[0053] The time information can be obtained, for example, by the RDY/ACK handshake in the VPU technology of PACT01, 02, 13. However, it should be particularly noted in this respect that the handshake does not represent a relevant state, either, since it only signals the validity of the data as a result of which the remaining relevant information is again reduced to the existence of valid data.

[0054] A distinction between locally and globally relevant states is demonstrated in PACT11:

[0055] Local: the state is only relevant within a single completed configuration. For this reason, it is not mandatory to store the state.

[0056] Global: the state information is needed for a number of configurations. The state must be stored.

[0057] It is now conceivable that the programmer wants to debug a locally relevant state which is not stored in the memories. In this case, the application must be modified to the extent that a debugging configuration is produced (equivalent to the debugging code of processors) which exhibits a modification of the “normal” code of the application in such a manner that this state is additionally written into the memory unit and is thus provided to the debugger.

[0058] 2.3 Visible Debugging Information

[0059] Debugging before the (pre)condition is comparatively simple and can be performed without great performance losses since the debugging information needed is available in memories. The debugging information can be saved simply by copying the memories into other memory areas. An even faster method is to switch the memories by means of a bank switching method (of the prior art) between the individual configurations in such a manner that the debugging information is located in a new bank in each case. The switching can be done in a very time-optimizing manner, even without effect on the processing performance in the optimum case.

[0060] In contrast to method A, irrelevant states can be picked up only with difficulty since they are not stored (especially according to PACT11). In special cases, however, they can be additionally stored within the debugging code similar to the locally relevant states, and/or a method is used in which method A and B are used jointly.

[0061] However, it should be mentioned that there does not appear to be any requirement for storing this information in the VPU technology according to PACT02. It is only when programmable sequences according to PACT13 are used instead of the SM unit (PACT02), that it is useful to debug irrelevant states.

[0062] 4. Operation of the Debugger

[0063] The debugger program itself runs on a DB outside the PA. The debugging information is read by the debugger according to method A or B and stored in a memory and/or memory area separate from the data processing. The debugger program defines the breakpoints and (pre)conditions. The debugger program can also take over control of the execution of the application, particularly the start of execution and the end of execution.

[0064] The debugger according to the invention can also communicate with other tools and particularly also debuggers according to PACT20 within a development environment, as a result of which the control and definition of the debugging parameters can be taken over from another debugger. Similarly, the debugger can provide the debugging information generated by it to another debugger or obtain from the latter its debugging information.

[0065] The determination of the occurrence of breakpoints and/or (pre)condition, in particular, can be performed by another debugger from the units debugged by this other debugger. The debugger according to the invention and the VPU then respond correspondingly.

[0066] 5. Evaluation of the Methods

[0067] Method A is considerably more time- and resource-intensive than method B in which hardly any additional hardware is required and moreover the time-consuming reading out of the debugging information from the start of the application may possibly be omitted. Method B must, therefore, be preferred in principle. However, applications which [lacuna] by the compilation of normal HDL source codes onto a VPU are scarcely suitable for applying method B. For compilers according to PACT11, however, method B must be clearly preferred.

6. DESCRIPTION OF THE FIGURES

[0068]FIGS. 1 and 2 correspond to patent application PACT11. The different approaches of methods A and B have been drawn into the figures (A, B)

[0069]FIG. 1b shows a representation of the finite state machine by a reconfigurable architecture according to PACT01 and PACT04 (PACT04, FIGS. 12-15). The combinatorial network of FIG. 1a (0101) is replaced by an arrangement of PAEs 0107 (0101 b). The register (0102) is executed by a memory (0102 b) which can store a number of cycles. The feedback according to 0105 is done by 0105 b. The inputs (0103 b and 0104 b, respectively) are equivalent to 0103 and 0104, respectively. The direct access to 0102 b may be implemented by a bus by the array 0101 b. The output 0106 b is again equivalent to 0106.

[0070]FIG. 2 shows the mapping of a finite state machine onto a reconfigurable architecture. 0201(x) represents the combinatorial network (which can be designed as PAEs according to FIG. 1b). There are one or more memories for operands (0202) and one or more memories for results (0203). Additional data inputs/outputs according to 0103 b, 0104 b, 0106 b are not shown for the sake of simplicity. The memories are in each case associated with an address generator (0204, 0205). The operand and result memories (0202, 0203) are physically or virtually coupled to one another in such a manner that, for example, the results of a function of another one can be used as operands and/or results and operands of a function of another one can be used as operands. Such coupling can be established, for example, by means of bus systems or by a (re)configuration by means of which the function and networking of the memories with the 0201 s is reconfigured.

[0071]FIG. 3 shows a possible diagrammatic structure of the debugging according to method B. Special reference is made to FIGS. 19, 20, 21 of patent application PACT13 in which the principle of the memories is described. PACT13 is herewith incorporated to its full extent.

[0072]0101 b and 0102 b is shown as already described. In addition, an external memory unit is shown (0302) which may possibly be connected (0307) to 0102 b similar to PACT13. Particular reference is made to the fact that both 0102 b and 0302 can be external or internal memory units. Similarly, a memory unit should be defined as at least one register, a set of registers or a memory (RAM, flash, hard disk or similar).

[0073] The debugging unit 0301 can set breakpoints within 0101 b (0303) on the basis of which the actual debugging process is triggered. When a breakpoint is reached, an information item (0304) is sent to 0301 which starts the debugging process; at the same time, all provisions for debugging internal to 0101 b, (e.g. stopping and/or slowing down of the clock) are triggered. As an alternative, information can also be generated by 0301 and sent to 0101 b. 0301 can access the data and/or states from the memory 0102 b and/or the memory 0302 via 0305 and/or 0306. The accessing can be done, for example, by

[0074] 1. shared memory (block move, i.e. copying the memories into another area controlled by 0301)

[0075] 2. a line (serial or parallel line via which one or more memory area(s) is/are transmitted, e.g. JTAG)

[0076] 3. bus couplings of any type (the memories are arbitrated similar to a DMA method and processed by 0301).

[0077] As an example, a figure from PACT13 has been selected. Express reference is made to the fact that, in principle, every memory method and every shared memory (stack, random access, FIFO etc.) can be correspondingly processed. 

1. Method for debugging reconfigurable hardware, wherein all necessary debugging information is written for each configuration cycle into a memory which is then evaluated by the debugger. 